home *** CD-ROM | disk | FTP | other *** search
/ Sprite 1984 - 1993 / Sprite 1984 - 1993.iso / src / cmds / cc / g++-dist / print-tree.c < prev    next >
Encoding:
C/C++ Source or Header  |  1990-01-16  |  16.0 KB  |  674 lines
  1. /* Prints out tree in human readable form - GNU C-compiler
  2.    Copyright (C) 1987 Free Software Foundation, Inc.
  3.  
  4. This file is part of GNU CC.
  5.  
  6. GNU CC is free software; you can redistribute it and/or modify
  7. it under the terms of the GNU General Public License as published by
  8. the Free Software Foundation; either version 1, or (at your option)
  9. any later version.
  10.  
  11. GNU CC is distributed in the hope that it will be useful,
  12. but WITHOUT ANY WARRANTY; without even the implied warranty of
  13. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14. GNU General Public License for more details.
  15.  
  16. You should have received a copy of the GNU General Public License
  17. along with GNU CC; see the file COPYING.  If not, write to
  18. the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  19.  
  20.  
  21. #include "config.h"
  22. #include "tree.h"
  23. #include <stdio.h>
  24.  
  25. extern char **tree_code_name;
  26.  
  27. extern char *mode_name[];
  28.  
  29. extern char spaces[];
  30.  
  31. #define MIN(x,y) ((x < y) ? x : y)
  32.  
  33. static FILE *outfile;
  34.  
  35. extern int tree_node_counter;
  36.  
  37. /* markvec[i] is 1 if node number i has been seen already.  */
  38.  
  39. static char *markvec;
  40.  
  41. static void dump ();
  42. void dump_tree ();
  43.  
  44. void
  45. debug_dump_tree (root)
  46.      tree root;
  47. {
  48.   dump_tree (stderr, root);
  49. }
  50.  
  51. void
  52. dump_tree (outf, root)
  53.      FILE *outf;
  54.      tree root;
  55. {
  56.   markvec = (char *) alloca (tree_node_counter + 1);
  57.   bzero (markvec, tree_node_counter + 1);
  58.   outfile = outf;
  59.   dump (root, 0);
  60.   fflush (outf);
  61. }
  62.  
  63. static
  64. void
  65. wruid (node)
  66.      tree node;
  67. {
  68.  
  69.   if (node == NULL)
  70.     fputs ("<>", outfile);
  71.   else {
  72.     fprintf (outfile, "%1d", TREE_UID (node));
  73.   }
  74. }
  75.  
  76. static 
  77. void
  78. part (title, node)
  79.      char title[];
  80.      tree node;
  81. {
  82.   fprintf (outfile, " %s = ", title);
  83.   wruid (node);
  84.   putc (';', outfile);
  85. }
  86.  
  87. /* Similar to `part' but prefix with @ if value is not constant
  88.    and print the constant value if it is constant.  */
  89. static
  90. void
  91. cpart (title, ct, punct)
  92.      char *title;
  93.      tree ct;
  94.      char punct;
  95. {
  96.   fprintf (outfile, " %s = ", title);
  97.   if (ct == NULL)
  98.     fputs ("<>", outfile);
  99.   else
  100.     {
  101.       if (!TREE_LITERAL (ct))
  102.     {
  103.       putc ('@', outfile);
  104.       wruid (ct);
  105.     }
  106.       else
  107.     fprintf (outfile, "%ld", TREE_INT_CST_LOW (ct));
  108.     }
  109.   putc (punct, outfile);
  110. }
  111.  
  112. static void
  113. walk (node, leaf, indent)
  114.      tree node;
  115.      tree leaf;
  116.      int indent;
  117. {
  118.   if (node != NULL
  119.       /* Don't walk any global nodes reached from local nodes!
  120.      The global nodes will be dumped at the end, all together.
  121.      Also don't mention a FUNCTION_DECL node that is marked local
  122.      since it was fully described when it was dumped locally.  */
  123.       && (TREE_CODE (node) != FUNCTION_DECL
  124.       || TREE_PERMANENT (node))
  125.       && (TREE_PERMANENT (leaf) == TREE_PERMANENT (node)))
  126.     dump (node, indent+1);
  127. }
  128.  
  129. static void
  130. cwalk (s, leaf, indent)
  131.      tree s;
  132.      tree leaf;
  133.      int indent;
  134. {
  135.   if (s != NULL) 
  136.     if (!TREE_LITERAL (s))
  137.       walk (s, leaf, indent);
  138. }
  139.  
  140. static void
  141. prtypeinfo (node)
  142.      register tree node;
  143. {
  144.   int first;
  145.   
  146.   part ("type", TREE_TYPE (node));
  147.   first = 1;
  148.   fputs (" [", outfile);
  149.   if (TREE_EXTERNAL (node))
  150.     {
  151.       if (!first) putc (' ', outfile);
  152.       fputs ("external", outfile);
  153.       first = 0;
  154.     }
  155.   if (TREE_PUBLIC (node))
  156.     {
  157.       if (!first) putc (' ', outfile);
  158.       fputs ("public", outfile);
  159.       first = 0;
  160.     }
  161.   if (TREE_STATIC (node))
  162.     {
  163.       if (!first) putc (' ', outfile);
  164.       fputs ("static", outfile);
  165.       first = 0;
  166.     }
  167.   if (TREE_VOLATILE (node))
  168.     {
  169.       if (!first) putc (' ', outfile);
  170.       fputs ("volatile", outfile);
  171.       first = 0;
  172.     }
  173.   if (TREE_PACKED (node))
  174.     {
  175.       if (!first) putc (' ', outfile);
  176.       fputs ("packed", outfile);
  177.       first = 0;
  178.     }
  179.   if (TREE_READONLY (node))
  180.     {
  181.       if (!first) putc (' ', outfile);
  182.       fputs ("readonly", outfile);
  183.       first = 0;
  184.     }
  185.   if (TREE_LITERAL (node))
  186.     {
  187.       if (!first) putc (' ', outfile);
  188.       fputs ("literal", outfile);
  189.       first = 0;
  190.     }
  191.   if (TREE_NONLOCAL (node))
  192.     {
  193.       if (!first) putc (' ', outfile);
  194.       fputs ("nonlocal", outfile);
  195.       first = 0;
  196.     }
  197.   if (TREE_ADDRESSABLE (node))
  198.     {
  199.       if (!first) putc (' ', outfile);
  200.       fputs ("addressable", outfile);
  201.       first = 0;
  202.     }
  203.   if (TREE_REGDECL (node))
  204.     {
  205.       if (!first) putc (' ', outfile);
  206.       fputs ("regdecl", outfile);
  207.       first = 0;
  208.     }
  209.   if (TREE_THIS_VOLATILE (node))
  210.     {
  211.       if (!first) putc (' ', outfile);
  212.       fputs ("this_vol", outfile);
  213.       first = 0;
  214.     }
  215.   if (TREE_UNSIGNED (node))
  216.     {
  217.       if (!first) putc (' ', outfile);
  218.       fputs ("unsigned", outfile);
  219.       first = 0;
  220.     }
  221.   if (TREE_ASM_WRITTEN (node))
  222.     {
  223.       if (!first) putc (' ', outfile);
  224.       fputs ("asm_written", outfile);
  225.       first = 0;
  226.     }
  227.   if (TREE_INLINE (node))
  228.     {
  229.       if (!first) putc (' ', outfile);
  230.       fputs ("inline", outfile);
  231.       first = 0;
  232.     }
  233.   if (TREE_USED (node))
  234.     {
  235.       if (!first) putc (' ', outfile);
  236.       fputs ("used", outfile);
  237.       first = 0;
  238.     }
  239.   if (TREE_PERMANENT (node))
  240.     {
  241.       if (!first) putc (' ', outfile);
  242.       fputs ("permanent", outfile);
  243.       first = 0;
  244.     }
  245.   if (TREE_LANG_FLAG_1 (node))
  246.     {
  247.       if (!first) putc (' ', outfile);
  248.       fputs ("lang_flag_1", outfile);
  249.       first = 0;
  250.     }
  251.   if (TREE_LANG_FLAG_2 (node))
  252.     {
  253.       if (!first) putc (' ', outfile);
  254.       fputs ("lang_flag_2", outfile);
  255.       first = 0;
  256.     }
  257.   if (TREE_LANG_FLAG_3 (node))
  258.     {
  259.       if (!first) putc (' ', outfile);
  260.       fputs ("lang_flag_3", outfile);
  261.       first = 0;
  262.     }
  263.   if (TREE_LANG_FLAG_4 (node))
  264.     {
  265.       if (!first) putc (' ', outfile);
  266.       fputs ("lang_flag_4", outfile);
  267.       first = 0;
  268.     }
  269.   fputs ("] ", outfile);
  270. }
  271.  
  272. static void
  273. prdeclmodeinfo (node)
  274.      tree node;
  275. {
  276.   register enum machine_mode mode = DECL_MODE (node);
  277.   fprintf (outfile, " %s;", mode_name[(int) mode]);
  278.  
  279.   cpart ("size", DECL_SIZE (node), '*');
  280.   fprintf (outfile, "%d;", DECL_SIZE_UNIT (node));
  281.  
  282.   fprintf (outfile, " alignment = %1d;", DECL_ALIGN (node));
  283. }
  284.  
  285. static void
  286. prtypemodeinfo (node)
  287.      tree node;
  288. {
  289.   register enum machine_mode mode = TYPE_MODE (node);
  290.   fprintf (outfile, " %s;", mode_name[(int) mode]);
  291.  
  292.   cpart ("size", TYPE_SIZE (node), '*');
  293.   fprintf (outfile, "%d;", TYPE_SIZE_UNIT (node));
  294.  
  295.   fprintf (outfile, " alignment = %1d;", TYPE_ALIGN (node));
  296. }
  297.  
  298. static void
  299. skip (indent)
  300.      int indent;
  301. {
  302.   putc ('\n',outfile);
  303.   fputs (spaces + (strlen (spaces) - (12 + MIN (40,(indent+1)*2))), outfile);
  304. }
  305.  
  306. /* Output a description of the tree node NODE
  307.    if its description has not been output already.  */
  308.  
  309. static 
  310. void
  311. dump (node, indent)
  312.      tree node;
  313.      int indent;
  314. {
  315.   register enum tree_code code = TREE_CODE (node);
  316.   register int i;
  317.   register int len, first_rtl;
  318.   int nochain = 0;
  319.  
  320.   if (markvec[TREE_UID (node)])
  321.     return;
  322.   markvec[TREE_UID (node)] = 1;
  323.  
  324.   fputs ("   ", outfile);
  325.   fprintf (outfile, "%5d", TREE_UID (node));
  326.   fputs (spaces + (strlen (spaces) - MIN (40, (indent+1)*2)), outfile);
  327.   fputs (tree_code_name[(int) code], outfile);
  328.  
  329.   switch (*tree_code_type[(int) code])
  330.     {
  331.     case 'd':
  332.       fputs (" name = ", outfile);
  333.       if (DECL_NAME (node) == NULL)
  334.     fputs ("<>;", outfile);
  335.       else
  336.     fprintf (outfile, "%s;",
  337.          IDENTIFIER_POINTER (DECL_NAME (node)));
  338.       if (code != PARM_DECL)
  339.     fprintf (outfile, " at %s line %d;",
  340.          DECL_SOURCE_FILE (node), DECL_SOURCE_LINE (node));
  341.       skip (indent);
  342.       prdeclmodeinfo (node);
  343.       prtypeinfo (node);
  344. #ifdef PRINT_LANG_DECL
  345.       print_lang_decl (node);
  346. #endif
  347.       skip (indent);
  348.       fprintf (outfile, " offset = %1d;", DECL_OFFSET (node));
  349.       if (DECL_VOFFSET (node) != NULL)
  350.     {
  351.       fputs ("voffset = ", outfile);
  352.       wruid (DECL_VOFFSET (node));
  353.       fprintf (outfile, "*%1d;", DECL_VOFFSET_UNIT (node));
  354.     }
  355.       part ("context", DECL_CONTEXT (node));
  356.       if (code == FUNCTION_DECL)
  357.     {
  358.       if (DECL_ARGUMENTS (node) || DECL_RESULT (node)
  359.           || DECL_INITIAL (node))
  360.         {
  361.           skip (indent);
  362.           part ("arguments", DECL_ARGUMENTS (node));
  363.           part ("result", DECL_RESULT (node));
  364.           if ((int) (DECL_INITIAL (node)) == 1)
  365.         fprintf (outfile, " initial = const 1;");
  366.           else
  367.         part ("initial", DECL_INITIAL (node));
  368.         }
  369.     }
  370.       else if (DECL_INITIAL (node))
  371.     {
  372.       if ((int) (DECL_INITIAL (node)) == 1)
  373.         fprintf (outfile, " initial = const 1;");
  374.       else
  375.         part ("initial", DECL_INITIAL (node));
  376.     }
  377. #ifdef PRINT_LANG_DECL
  378.       walk_lang_decl (node);
  379. #endif
  380.       part ("chain", TREE_CHAIN (node));
  381.       /* A Decl's chain contents is not part of the decl.  */
  382.       nochain = 1;
  383.       fputc ('\n', outfile);
  384.       cwalk (DECL_SIZE (node), node, indent);
  385.       walk (TREE_TYPE (node), node, indent);
  386.       walk (DECL_VOFFSET (node), node, indent);
  387.       walk (DECL_CONTEXT (node), node, indent);
  388.       if (code == FUNCTION_DECL)
  389.     {
  390.       walk (DECL_ARGUMENTS (node), node, indent);
  391.       walk (DECL_RESULT (node), node, indent);
  392.     }
  393.       if ((int) (DECL_INITIAL (node)) != 1)
  394.     walk (DECL_INITIAL (node), node, indent);
  395.       break;
  396.  
  397.     case 't':
  398.       prtypemodeinfo (node);
  399.       prtypeinfo (node);
  400. #ifdef PRINT_LANG_TYPE
  401.       print_lang_type (node);
  402. #endif
  403.       skip (indent);
  404.       part ("pointers_to_this", TYPE_POINTER_TO (node));
  405.       if (code == ARRAY_TYPE || code == SET_TYPE)
  406.     {
  407.       part ("domain", TYPE_DOMAIN (node));
  408.       cpart ("separation", TYPE_SEP (node), '*');
  409.       fprintf (outfile, "%d;", TYPE_SEP_UNIT (node));
  410.     }
  411.       else if (code == INTEGER_TYPE)
  412.     {
  413.       cpart ("min", TYPE_MIN_VALUE (node), ';');
  414.       cpart ("max", TYPE_MAX_VALUE (node), ';');
  415.       fprintf (outfile, "precision = %d;", TYPE_PRECISION (node));
  416.     }
  417.       else if (code == ENUMERAL_TYPE)
  418.     {
  419.       cpart ("min", TYPE_MIN_VALUE (node), ';');
  420.       cpart ("max", TYPE_MAX_VALUE (node), ';');
  421.       part ("values", TYPE_VALUES (node));
  422.       fprintf (outfile, "precision = %d;", TYPE_PRECISION (node));
  423.     }
  424.       else if (code == REAL_TYPE)
  425.     {
  426.       fprintf (outfile, "precision = %d;", TYPE_PRECISION (node));
  427.     }
  428.       else if (code == RECORD_TYPE
  429.            || code == UNION_TYPE)
  430.     {
  431.       part ("fields", TYPE_FIELDS (node));
  432.     }
  433.       else if (code == FUNCTION_TYPE)
  434.     {
  435.       part ("arg_types", TYPE_ARG_TYPES (node));
  436.     }
  437.       else if (code == METHOD_TYPE)
  438.     {
  439.       part ("arg_types", TYPE_ARG_TYPES (node));
  440.     }
  441. #ifdef PRINT_LANG_TYPE
  442.       walk_lang_type (node);
  443. #endif
  444.       part ("chain", TREE_CHAIN (node));
  445.       /* A type's chain's contents are not printed because the chain of types
  446.      is not part of the meaning of any particular type.  */
  447.       nochain = 1;
  448.       fputc ('\n', outfile);
  449.       cwalk (TYPE_SIZE (node), node, indent);
  450.       walk (TREE_TYPE (node), node, indent);
  451.       walk (TYPE_VALUES (node), node, indent);
  452.       walk (TYPE_SEP (node), node, indent);
  453.       walk (TYPE_POINTER_TO (node), node, indent);
  454.       walk (TYPE_REFERENCE_TO (node), node, indent);
  455.       break;
  456.  
  457.     case 'e':
  458.     case 'r':
  459.       prtypeinfo (node);
  460.       fputs (" ops =", outfile);
  461.       first_rtl = len = tree_code_length[(int) code];
  462.       /* These kinds of nodes contain rtx's, not trees,
  463.      after a certain point.  Print the rtx's as rtx's.  */
  464.       switch (code)
  465.     {
  466.     case SAVE_EXPR:
  467.       first_rtl = 1;
  468.       break;
  469.     case CALL_EXPR:
  470.       first_rtl = 2;
  471.       break;
  472.     case METHOD_CALL_EXPR:
  473.       first_rtl = 3;
  474.       break;
  475.     case WITH_CLEANUP_EXPR:
  476.       /* Should be defined to be 2.  */
  477.       first_rtl = 1;
  478.       break;
  479.     case RTL_EXPR:
  480.       first_rtl = 0;
  481.     }
  482.       for (i = 0; i < len; i++)
  483.     {
  484.       if (i >= first_rtl)
  485.         {
  486.           skip (indent);
  487.           if (TREE_OPERAND (node, i))
  488.         print_rtl (outfile, TREE_OPERAND (node, i));
  489.           else
  490.         fprintf (outfile, "(nil)");
  491.           fprintf (outfile, "\n");
  492.         }
  493.       else
  494.         {
  495.           fputs (" ", outfile);
  496.           wruid (TREE_OPERAND (node, i));
  497.           fputs (";", outfile);
  498.         }
  499.     }
  500.       part ("chain", TREE_CHAIN (node));
  501.       fputc ('\n', outfile);
  502.       walk (TREE_TYPE (node), node, indent);
  503.       for (i = 0; i < len && i < first_rtl; i++)
  504.     walk (TREE_OPERAND (node, i), node, indent);
  505.       break;
  506.  
  507.     case 's':
  508.       prtypeinfo (node);
  509.       fprintf (outfile, " at %s line %d;",
  510.            STMT_SOURCE_FILE (node), STMT_SOURCE_LINE (node));
  511.       switch (TREE_CODE (node))
  512.     {
  513.     case IF_STMT:
  514.       part ("cond", STMT_COND (node));
  515.       part ("then", STMT_THEN (node));
  516.       part ("else", STMT_ELSE (node));
  517.       break;
  518.  
  519.     case LET_STMT:
  520.     case WITH_STMT:
  521.       part ("vars", STMT_VARS (node));
  522.       part ("tags", STMT_TYPE_TAGS (node));
  523.       part ("supercontext", STMT_SUPERCONTEXT (node));
  524.       part ("bind_size", STMT_BIND_SIZE (node));
  525.       part ("body", STMT_BODY (node));
  526.       part ("subblocks", STMT_SUBBLOCKS (node));
  527.       break;
  528.  
  529.     case CASE_STMT:
  530.       part ("case_index", STMT_CASE_INDEX (node));
  531.       part ("case_list", STMT_CASE_LIST (node));
  532.       break;
  533.  
  534.     default:
  535.       part ("body", STMT_BODY (node));
  536.       break;
  537.     }
  538.       part ("chain", TREE_CHAIN (node));
  539.       fputc ('\n', outfile);
  540.       walk (TREE_TYPE (node), node, indent);
  541.       switch (TREE_CODE (node))
  542.     {
  543.     case IF_STMT:
  544.       walk (STMT_COND (node), node, indent);
  545.       walk (STMT_THEN (node), node, indent);
  546.       walk (STMT_ELSE (node), node, indent);
  547.       break;
  548.  
  549.     case LET_STMT:
  550.     case WITH_STMT:
  551.       walk (STMT_VARS (node), node, indent);
  552.       walk (STMT_TYPE_TAGS (node), node, indent);
  553.       walk (STMT_SUPERCONTEXT (node), node, indent);
  554.       walk (STMT_BIND_SIZE (node), node, indent);
  555.       walk (STMT_BODY (node), node, indent);
  556.       walk (STMT_SUBBLOCKS (node), node, indent);
  557.       break;
  558.  
  559.     case CASE_STMT:
  560.       walk (STMT_CASE_INDEX (node), node, indent);
  561.       walk (STMT_CASE_LIST (node), node, indent);
  562.       break;
  563.  
  564.     default:
  565.       walk (STMT_BODY (node), node, indent);
  566.       break;
  567.     }
  568.       break;
  569.  
  570.     case 'c':
  571.       switch (code)
  572.     {
  573.     case INTEGER_CST:
  574.       if (TREE_INT_CST_HIGH (node) == 0)
  575.         fprintf (outfile, " = %1u;", TREE_INT_CST_LOW (node));
  576.       else if (TREE_INT_CST_HIGH (node) == -1
  577.            && TREE_INT_CST_LOW (node) != 0)
  578.         fprintf (outfile, " = -%1u;", -TREE_INT_CST_LOW (node));
  579.       else
  580.         fprintf (outfile, " = 0x%x%08x;",
  581.              TREE_INT_CST_HIGH (node),
  582.              TREE_INT_CST_LOW (node));
  583.       break;
  584.  
  585.     case REAL_CST:
  586. #ifndef REAL_IS_NOT_DOUBLE
  587.       fprintf (outfile, " = %e;", TREE_REAL_CST (node));
  588. #else
  589.       {
  590.         int i;
  591.         char *p = (char *) &TREE_REAL_CST (node);
  592.         fprintf (outfile, " = 0x");
  593.         for (i = 0; i < sizeof TREE_REAL_CST (node); i++)
  594.           fprintf (outfile, "%02x", *p++);
  595.         fprintf (outfile, ";");
  596.       }
  597. #endif /* REAL_IS_NOT_DOUBLE */
  598.       break;
  599.  
  600.     case COMPLEX_CST:
  601.       part ("realpart", TREE_REALPART (node));
  602.       part ("imagpart", TREE_IMAGPART (node));
  603.       walk (TREE_REALPART (node), node, indent);
  604.       walk (TREE_IMAGPART (node), node, indent);
  605.       break;
  606.  
  607.     case STRING_CST:
  608.       fprintf (outfile, " = \"%s\";", TREE_STRING_POINTER (node));
  609.     }
  610.       prtypeinfo (node);
  611.       part ("chain", TREE_CHAIN (node));
  612.       fputc ('\n', outfile);
  613.       walk (TREE_TYPE (node), node, indent);
  614.       break;
  615.  
  616.     case 'x':
  617.       if (code == IDENTIFIER_NODE)
  618.     {
  619.       fprintf (outfile, " = %s;\n", IDENTIFIER_POINTER (node));
  620.       nochain = 1;
  621.     }
  622.       else if (code == TREE_LIST)
  623.     {
  624.       prtypeinfo (node);
  625.       part ("purpose", TREE_PURPOSE (node));
  626.       part ("value", TREE_VALUE (node));
  627.       part ("chain", TREE_CHAIN (node));
  628.       fputc ('\n', outfile);
  629.       walk (TREE_TYPE (node), node, indent);
  630.       walk (TREE_PURPOSE (node), node, indent);
  631.       walk (TREE_VALUE (node), node, indent);
  632.     }
  633.       else if (code == TREE_VEC)
  634.     {
  635.       prtypeinfo (node);
  636.       len = TREE_VEC_LENGTH (node);
  637.       fprintf (outfile, "length = %d\n", len);
  638.       for (i = 0; i < len; i++)
  639.         {
  640.           fputs (" ", outfile);
  641.           wruid (TREE_VEC_ELT (node, i));
  642.           fputs (";", outfile);
  643.         }
  644.       part ("chain", TREE_CHAIN (node));
  645.       fputc ('\n', outfile);
  646.       walk (TREE_TYPE (node), node, indent);
  647.       for (i = 0; i < len; i++)
  648.         walk (TREE_VEC_ELT (node, i), node, indent);
  649.     }
  650.       else if (code == OP_IDENTIFIER)
  651.     {
  652.       prtypeinfo (node);
  653.       part ("op1", TREE_PURPOSE (node));
  654.       part ("op2", TREE_VALUE (node));
  655.       part ("chain", TREE_CHAIN (node));
  656.       fputc ('\n', outfile);
  657.       walk (TREE_TYPE (node), node, indent);
  658.       walk (TREE_PURPOSE (node), node, indent);
  659.       walk (TREE_VALUE (node), node, indent);
  660.     }
  661.       else if (code == ERROR_MARK)
  662.     fputc ('\n', outfile);
  663.       else abort ();
  664.  
  665.       break;
  666.  
  667.     default:
  668.       abort ();
  669.     } /* switch */
  670.  
  671.   if (TREE_CHAIN (node) != NULL && ! nochain)
  672.     dump (TREE_CHAIN (node), indent);
  673. }
  674.